home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
HPAVC
/
HPAVC CD-ROM.iso
/
PASCTXT.ZIP
/
CHAP9.TXT
< prev
next >
Wrap
Text File
|
1988-01-15
|
21KB
|
455 lines
CHAPTER 9 - Records
We come to the grandaddy of all data structures in
Pascal, the record. A record is composed of a number of
variables any of which can be of any predefined data type,
including other records. Rather than spend time trying to
define a record in detail, lets go right to the first
example program, SMALLREC. This is a program using nonsense
data that will illustrate the use of a record.
A VERY SIMPLE RECORD
There is only one entry in the type declaration part of
the program, namely the record identified by the name
Description. The record is composed of three fields, the
Year, Model, and Engine variables. Notice that the three
fields are each of a different type, indicating that the
record can be of mixed types. You have a complete example
of the way a record is defined before you. It is composed
of the identifier Description, the reserved word "record",
the list of elements, and followed by end. This is one of
the places in Pascal where an end is used without a
corresponding begin. Notice that this only defines a type,
it does not define any variables. That is done in the var
declaration where the variable Cars is defined to have 10
complete records of the type Description. The variable
Cars[1] has three components, Year, Model, and Engine, and
any or all of these components can be used to store data
pertaining to Cars[1].
When assigning data to the variable Cars[1], for
example, there are actually three parts to the variable, so
we use three assignment statements, one for each of the
sub-fields. In order to assign values to the various
sub-fields, the variable name is followed by the sub-field
name with a separating period. The "var.sub_field"
combination is a variable name.
Keep in mind that Cars[1] is a complete record
containing three variables, and to assign or use one of the
variables, you must designate which sub-field you are
interested in. See the program where the three fields are
assigned meaningless data for illustration. The Year field
is assigned an integer number varying with the subscript,
all Model fields are assigned the name Duesenburg, and all
Engine variables are assigned the value V8. In order to
further illustrate that there are actually 30 variables in
use here, a few are changed at random in lines 20 through
24, being very careful to maintain the required types as
defined in the type declaration part of the program.
Finally, all ten composite variables, consisting of 30
actual variables in a logical grouping are printed out using
the same "var.sub-field" notation described above.
Page 51
CHAPTER 9 - Records
If the preceding description of a record is not clear
in your mind, review it very carefully. It's a very
important concept in Pascal, and you won't have a hope of a
chance of understanding the next example until this one is
clear.
Be sure to compile and run SMALLREC so you can study
the output.
A SUPER RECORD
Examine the Pascal example file BIGREC for a very
interesting record. First we have a constant defined.
Ignore it for the moment, we will come back to it later.
Within the type declaration we have three records defined,
and upon close examination, you will notice that the first
two records are included as part of the definition of the
third record. The record identified as Person, actually
contains 9 variable definitions, three within the Full_Name
record, three of its own, and three within the Date record.
This is a type declaration and does not actually define any
variables, that is done in the var part of the program.
The var part of the program defines some variables
beginning with the array of Friend containing 50 (because of
the constant definition in the const part) records of the
user defined type, Person. Since the type Person defines 9
fields, we have now defined 9 times 50 = 450 separate and
distinct variables, each with its own defined type.
Remember that Pascal is picky about assigning data by the
correct type. Each of the 450 separate variables has its
own type associated with it, and the compiler will generate
an error if you try to assign any of those variables the
wrong type of data. Since Person is a type definition, it
can be used to define more than one variable, and in fact it
is used again to define three more records, Self, Mother,
and Father. These three records are each composed of 9
variables, so we have 27 more variables which we can
manipulate within the program. Finally we have the variable
Index defined as a simple byte type variable.
HOW TO MANIPULATE ALL OF THAT DATA
In the program we begin by assigning data to all of the
fields of Self in lines 31 through 43. Examining the first
three statements of the main program, we see the
construction we learned in the last example program being
used, namely the period between descriptor fields. The main
record is named Self, and we are interested in the first
part of it, specifically the Name part of the Person record.
Page 52
CHAPTER 9 - Records
Since the Name part of the Person record is itself composed
of three parts, we must designate which component of it we
are interested in. Self.Name.First_Name is the complete
description of the first name of Self and is used in the
assignment statement in line 31 where it is assigned the
name of "Charley". The next two fields are handled in the
same way and are self explanatory.
WHAT IS THE WITH STATEMENT?
Continuing on to the fourth field, the City, there are
only two levels required because City is not another record
definition. The fourth field is therefore completely
defined by Self.City. Notice the "with Self do" statement.
This is a shorthand notation used with record definitions to
simplify coding. From the begin in line 34 to the matching
end in line 43, any variables within the Self record are
used as though they had a "Self." in front of them. It
greatly simplifies coding to be able to omit the leading
identifier within the with section of code. You will see
that City, State, and Zipcode are easily assigned values
without further reference to the Self variable. When we get
to the Day part of the birthday, we are back to three levels
and the complete definition is Self.Birthday.Day but once
again, the "Self." part is taken care of automatically
because we are still within the "with Self do" area.
To illustrate the with statement further, another is
introduced in line 39, "with Birthday do", and an area is
defined by the begin end pair which extends from line 39
through line 42. Within this area both leading identifiers
are handled automatically to simplify coding, and Month is
equivalent to writing Self.Birthday.Month if both with
statements were removed.
HOW FAR DOWN CAN YOU NEST THE WITH STATEMENT?
You may be wondering how many levels of nesting are
allowed in record definitions. There doesn't appear to be a
limit according to the Pascal definition, but we do get a
hint at how far it is possible to go. In TURBO Pascal, you
are allowed to have with statements nested to nine levels,
and it would be worthless to nest with statements deeper
than the level of records. Any program requiring more
levels than nine is probably far beyond the scope of your
programming ability, and mine, for a long time. Pascal
implementations other than TURBO Pascal probably have their
own with statement nesting limitation. Check your reference
manual.
Page 53
CHAPTER 9 - Records
After assigning a value to Year, the entire record of
Self is defined, all nine variables. It should be pointed
out that even though Self is composed of nine separate
variables, it is proper to call Self a variable itself
because it is a record variable.
SUPER-ASSIGNMENT STATEMENTS
The statement in line 45, "Mother := Self;" is very
interesting. Since both of these are records, both are the
same type of record, and both therefore contain 9 variables,
Pascal is smart enough to recognize that, and assign all
nine values contained in Self to the corresponding variables
of Mother. So after one statement, the record variable
Mother is completely defined. The statement in line 46
assigns the same values to the nine respective variables of
Father, and the next two lines assign all 50 Friend
variables the same data. By this point in the program, we
have therefore generated 450 + 27 = 477 separate pieces of
data so far in this program. We could print it all out, but
since it is nonsense data, it would only waste time and
paper. Lines 49 through 52 write out three sample pieces of
the data for your inspection.
WHAT GOOD IS ALL OF THIS
It should be obvious to you that what this program
does, even though the data is nonsense, appears to be the
beginning of a database management system, which indeed it
is. Instead of assigning nonsense data, a list could be
read in and stored for manipulation. It is a crude
beginning, and has a long way to go to be useful, but you
should see a seed for a useful program.
Now to go back to the const in line 4 as promised. The
number of friends was defined as 50 and used for the size of
the array and in the assignment loop in line 47. You can
now edit this number and see how big this database can
become on your computer. If you are using TURBO Pascal, you
will be limited to slightly more than 1000 because of the
64K limitation of an executable program, and the fact that
all of this data is stored within that 64K boundary. It
should be noted that TURBO Pascal 4.0 allows a program
larger than 64K but still places a limitation of 64K on each
compilation unit. See how big you can make the number of
friends before you get the memory overflow message. Keep
the number in mind because when we get to the chapter on
Pointers and Dynamic Allocation, you will see a marked
increase in allowable size, especially if you have a large
amount of RAM installed in your computer.
Page 54
CHAPTER 9 - Records
A VARIANT RECORD
If any part of this chapter is still unclear, it would
be good for you to go back and review it at this time. The
next example will really tax your mind to completely
understand it, especially if the prior material is not
clear.
Examine the Pascal program VARREC for an example of a
program with a variant record definition. In this example,
we first define a scalar type, namely Kind_Of_Vehicle for
use within the record. Then we have a record defining
Vehicle, intended to define several different vehicles, each
with different kinds of data. It would be possible to
define all variables for all types of vehicles, but it would
be a waste of storage space to define the number of tires
for a boat, or the number of propeller blades used on a car
or truck. The variant record lets us define the data
precisely for each vehicle without wasting data storage
space.
WHAT IS A TAG-FIELD?
In the record definition we have the usual record
header followed by three variables defined in the same
manner as the records in the last two example programs.
Then we come to the case statement. Following this
statement, the record is different for each of the four
types defined in the associated scalar definition. The
variable What_Kind is called the tag-field and must be
defined as a scalar type prior to the record definition.
The tag-field is used to select the variant, when the
program uses one of the variables of this record type. The
tag-field is followed by a colon and its type definition,
then the reserved word "of". A list of the variants is then
given, with each of the variants having the variables for
its particular case defined. The list of variables for one
variant is called the field list.
A few rules are in order at this point. The variants
do not have to have the same number of variables in each
field list, and in fact, one or more of the variants may
have no variables at all in its variant part. If a variant
has no variables, it must still be defined with a pair of
empty parentheses followed by a semi-colon. All variables
in the entire variant part must have unique names. The
three variables, Wheels, Tires, and Tyres, all mean the same
thing to the user, but they must be different for the
compiler. You may use the same identifiers again in other
records and for simple variables anywhere else in the
program. The Pascal compiler can tell which variable you
Page 55
CHAPTER 9 - Records
mean by its context. Using the same variable name should be
discouraged as bad programming practice because it may
confuse you or another person trying to understand your
program at a later date.
The final rule is that the variant part of the record
must be the last part of it, and in fact, the last part of
any or all variants can itself have a variant part to it.
That is getting pretty advanced for our level of use of
Pascal at this time however.
USING THE VARIANT RECORD
We properly define four variables with the record type
Vehicle in line 22 and go on to examine the program itself.
We begin by defining one of our variables of type
Vehicle, namely the variable named Ford. The seven lines
assigning values to Ford are similar to the prior examples
with the exception of line 28. In that line the tag-field
which selects the particular variant used is set equal to
the value Truck, which is a scalar definition, not a
variable. This means that the variables named Motor, Tires,
and Payload are available for use with the record Ford, but
the variables named Wheels, Engine, Tyres, etc. are not
available in the record named Ford.
Next, we will define the record Sunfish as a Boat, and
define all of its variables in lines 33 through 41. All of
Sunfish's variables are defined but in a rather random order
to illustrate that they need not be defined in a particular
order. You should remember the with statement from the last
example program.
To go even further in randomly assigning the variables
to a record, we redefine Ford as having an Engine which it
can only have if it is a car. This is one of the fine
points of the Pascal record. If you assign any of the
variant variables, the record is changed to that variant,
but it is the programmers responsibility to assign the
correct tag-field to the record, not Pascal's. Good
programming practice would be to assign the tag-field before
assigning any of the variant variables. The remainder of
the Ford variables are assigned to complete that record, the
non-variant part remaining from the last assignment.
The variable Mac is now set equal to the variable
Sunfish in line 48. All variables within the record are
copied to Mac including the tag-field, making Mac a Boat.
Page 56
CHAPTER 9 - Records
NOW TO SEE WHAT WE HAVE IN THE RECORDS
We have assigned Ford to be a car, and two boats exist,
namely Sunfish and Mac. Since Schwinn was never defined, it
has no data in it, and is at this point useless. The Ford
tag-field has been defined as a car, so it should be true in
the if statement, and the message in line 51 should print.
The Sunfish is not a bicycle, so it will not print. The Mac
has been defined as a boat in the single assignment
statement, so it will print a message with an indication
that all of the data in the record was transferred to its
variables.
Even though we can make assignment statements with
records, they cannot be used in any mathematical operations
such as addition, or multiplication. They are simply used
for data storage. It is true however, that the individual
elements in a record can be used in any mathematical
statements legal for their respective types.
One other point should be mentioned. The tag-field can
be completely eliminated resulting in a "free union" variant
record. This is possible because Pascal, as you may
remember from above, will automatically assign the variant
required when you assign data to one of the variables within
a variant. This is the reason that all variables within any
of the variants must have unique names. The free union
record should be avoided in your early programming efforts
because you cannot test a record to see what variant it has
been assigned to it. It is definitely an advanced technique
in Pascal.
Be sure you compile and run VARREC and study the output
until you understand it completely.
PROGRAMMING EXERCISE
1. Write a simple program with a record to store the names
of five of your friends and display the names.
Page 57
